#include<iostream>
#include<memory>
#include<vector>
#include<string>
#include <string>  
#include <fstream>  
#include <streambuf>  
#include <sstream>
#include <cstdlib>
#include <new>
#include <typeinfo>

using namespace std;


class Foo{
public:
    Foo(){}; // 默认构造函数
    ~Foo(){};
    Foo(const Foo&){};  // coy constructor 拷贝构造函数
};

class Sales_data{
public:
    Sales_data(){}; // 默认构造函数
    Sales_data(const Sales_data&);  // 拷贝构造函数
    ~Sales_data(){};
private:
    std::string bookNo;
    int units_sold = 0;
    double revenue = 0.0;
};

Sales_data::Sales_data(const Sales_data& orig):    
        bookNo(orig.bookNo),
        units_sold(orig.units_sold),
        revenue(orig.revenue){}




class Quote{ //基类
public:
    Quote() = default;
    string isbn() const {}; // 基类和派生类一样
    // C++多态(polymorphism)是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写
    virtual double net_price(size_t n) const {
        printf("Quote prince %d  \n",n);
    };   // 基类和派生类不一样 // 派生类有自己的版本 //多态
                                                // const 成员函数(const的作用:说明其不会修改数据成员)


};


// 派生类
// 派生类列表
class Bluk_quote:public Quote{  // Bluk_quote继承了Quote
public:
    double net_price(size_t n) const override {
        printf("Bluk_quote prince %d \n",n);
    }; // override显式的说明了派生类中改写轮基类中的函数


};


double print_total(const Quote& item, size_t n){
    double ret = item.net_price(n);
    // cout<<"ISBN total price  "<<ret<<endl;
}


// void* operator new(size_t size){
//     if(void* mem = malloc(size)){
//         return mem;
//     } else {
//         throw bad_alloc();
//     }
// }

// // noexcept表示函数或者操作不会发生异常
// void operator delete(void* mem) noexcept{
//     free(mem);
// }





// class A{};
// class B: public A{};
// class C:public B{};


void* operator new(size_t size){
    if(void* mem = malloc(size)){
        return mem;
    }else{
        throw bad_alloc();
    }
}

void operator delete(void* mem) noexcept { 
        free(mem); 
    }



class Base{
public: 
    Base(){};
    virtual ~Base(){};
};

class Derived:public Base{
public:
    Derived(){};
    virtual ~Derived(){};
};




// class Base{
//     friend bool operator==(const Base&, const Base&);
//     public:
//     protected:
//         virtual bool equal(const Base&) const;
// };




enum class open_modes{
    input,output,append
};

// 不限作用域的enum去掉关键字class或者struct
enum color{
    red,yellow,green
};

enum{floatPrec=6, doublePrec=10,double_doublePrec=10};

// enum stoplight{red,yellow,green};


class Screen{
public:
    typedef string::size_type pos;
    char get_cursor() const {return contents[cursor];}
    char get() const;
    char get(pos ht, pos wd) const;
    Screen& home();
    Screen& forward();
    Screen& back();
    Screen& up();
    // action是一个指针
    using Action = Screen& (Screen::*)();
    enum Directions{Home,Forward,Back,Up};
    Screen& move(Directions);
// private:
    string contents;
    pos cursor;
    pos height,width;
private:
    static Action Menu[]; //函数表
};

// Screen& Screen::move(Directions cm){
//  return (this->*Menu[cm])(); // Menu[cm]指向一个成员函数
// }

// Screen::Action Screen::Menu[] = {
//     &Screen::home,
//     &Screen::forward,

// };



// class A{
// public:
//     void print();
// };

// void A::print(){
//     cout<<"A::print"<<endl;
// }



// using pClassF = void(A::*)(); // 类A的成员函数的指针类型,A::*表示是类A的成员指针，接着的()表示是无参的函数类型


int add(int a, int b){
    return (a+b);
}

int subtraction(int a, int b ){
    return (a-b);
}

struct  p_fun{
    int(* pFunAdd)(int a, int b);
    int(* pFunSubtraction)(int a, int b);
};

int func_1(int x){}; // 申明一个函数
int(*f)(int x);  // 申明一个函数指针





void fff(int x){
    cout<<"fff x "<<x<<endl;
}

void fcn( void(*fp)(int),int x ){ // 形参为函数指针
    fp(x);
}

typedef void(*Ftype)(int); // 定义一个函数指针的类型Ftype

void fcn0(Ftype fp, int x){
    fp(x);
}


// class A{
// public: 
//     A(int aa=0):a(aa){}
//     ~A(){}

//     void setA(int aa=1){
//         a=aa;
//     }

//     virtual void print(){
//         cout<<"A "<<a<<endl;
//     }

//     virtual void print_1(){
//         cout<<"A_1 "<<a<<endl;
//     }

// private:
//     int a;
// };


// class B:public A{
// public:
//     B():A(),b(0){}
//     B(int aa, int bb):A(aa),b(bb){}
//     ~B() {}

//     virtual void print(){
//         A::print();
//         cout<<"B: "<<b<<endl;
//     }

// virtual void printa()
// 		{
// 			A::print_1();
// 			cout << "B: " << b << endl;
// 		}

// private:
//     int b;
// };




class A{
public:
    //p1是一个指向非static成员函数的函数指针
    void (A::*p1)(void);
    //p2是一个指向static成员函数的函数指针
    void (*p2)(void);

    A(){
    p1 = &A::funa;
    p2 = &A::funb;
    }

void funa(void){
    puts("A");
}

static void funb(void){
    puts("B");
}


};




typedef unsigned int Bit;
class File{
    Bit mode:2; // 占2位
    Bit modified: 1;
    Bit prot_owner: 3;

};



template<typename T>
int compare(const T& v1, const T& v2){
    if(v1<v2) return -1;
    if(v2<v1) return 1;
    return 0;
}


template <unsigned N, unsigned M>
int compare(const char(&p1)[N], const char(&p2)[M] ){
    return strcmp(p1,p2);
}



template<typename T>class Blob{
public:
    typedef T value_type;
    typedef typename std::vector<T>::size_type size_type;
    // 构造函数
    Blob();
    Blob(std::initializer_list<T> il);
    // Blob中的元素数目
    size_type size() const {return data->size();}
    bool empty() const {return data->empty();}




};




int main(){





    cout<<"hello world"<<endl;
    return 0;
}